Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/x/volume8/xinvaders/patch2.02

Text File | 1990-08-15 | 15.9 KB | 420 lines

Path: uunet!wuarchive!usc!apple!sun-barr!newstop!sun!parc.xerox.com
From: [e-mail] (Jonny Goldman)
Newsgroups: comp.sources.x
Subject: v08i071: xinvaders -- space invaders for X, Patch2, Part02/02
Message-ID: <[e-mail]>
Date: 16 Aug 90 02:57:08 GMT
Sender: [e-mail]
Lines: 409
Approved: [e-mail]

Submitted-by: Jonny Goldman <[e-mail]>
Posting-number: Volume 8, Issue 71
Archive-name: xinvaders/patch2.02
Patch-To: xinvaders: Volume 8, Issue 62-66,68

These are the new bitmaps for patch #2 of xinvaders

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of shell archive."
# Contents:  base1.bit base2.bit explode1.bit explode2.bit spacer1.bit
#   spacer2.bit sperma1.bit sperma2.bit spermb1.bit spermb2.bit
#   vader1a1.bit vader1a2.bit vader1b1.bit vader1b2.bit vader2a1.bit
#   vader2a2.bit vader2b1.bit vader2b2.bit vader3a1.bit vader3a2.bit
#   vader3b1.bit vader3b2.bit
# Wrapped by jgoldman@philo on Sun Aug 12 01:07:42 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'base1.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'base1.bit'\"
else
echo shar: Extracting \"'base1.bit'\" \(215 characters\)
sed "s/^X//" >'base1.bit' <<'END_OF_FILE'
X#define explosion_width 15
X#define explosion_height 10
Xstatic char explosion_bits[] = {
X   0x80, 0x00, 0xc0, 0x01, 0xc0, 0x01, 0xe0, 0x03, 0xfe, 0x3f, 0xff, 0x7f,
X   0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f};
END_OF_FILE
if test 215 -ne `wc -c <'base1.bit'`; then
    echo shar: \"'base1.bit'\" unpacked with wrong size!
fi
# end of 'base1.bit'
fi
if test -f 'base2.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'base2.bit'\"
else
echo shar: Extracting \"'base2.bit'\" \(584 characters\)
sed "s/^X//" >'base2.bit' <<'END_OF_FILE'
X#define newbase_width 30
X#define newbase_height 20
Xstatic char newbase_bits[] = {
X   0x00, 0xc0, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00,
X   0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00,
X   0x00, 0xfc, 0x0f, 0x00, 0x00, 0xfc, 0x0f, 0x00, 0xfc, 0xff, 0xff, 0x0f,
X   0xfc, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x3f,
X   0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x3f,
X   0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x3f,
X   0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x3f};
END_OF_FILE
if test 584 -ne `wc -c <'base2.bit'`; then
    echo shar: \"'base2.bit'\" unpacked with wrong size!
fi
# end of 'base2.bit'
fi
if test -f 'explode1.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'explode1.bit'\"
else
echo shar: Extracting \"'explode1.bit'\" \(215 characters\)
sed "s/^X//" >'explode1.bit' <<'END_OF_FILE'
X#define explosion_width 15
X#define explosion_height 10
Xstatic char explosion_bits[] = {
X   0x80, 0x00, 0xc0, 0x01, 0xc0, 0x01, 0x20, 0x02, 0x3e, 0x3e, 0x0d, 0x50,
X   0x15, 0x48, 0x6d, 0x5b, 0x65, 0x4b, 0xff, 0x7f};
END_OF_FILE
if test 215 -ne `wc -c <'explode1.bit'`; then
    echo shar: \"'explode1.bit'\" unpacked with wrong size!
fi
# end of 'explode1.bit'
fi
if test -f 'explode2.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'explode2.bit'\"
else
echo shar: Extracting \"'explode2.bit'\" \(584 characters\)
sed "s/^X//" >'explode2.bit' <<'END_OF_FILE'
X#define newbase_width 30
X#define newbase_height 20
Xstatic char newbase_bits[] = {
X   0x00, 0xc0, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00,
X   0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00,
X   0x00, 0xfc, 0x0f, 0x00, 0x00, 0xfc, 0x0f, 0x00, 0xfc, 0xff, 0xff, 0x0f,
X   0xfc, 0xff, 0xff, 0x0f, 0x07, 0x00, 0x00, 0x38, 0xf3, 0x00, 0x00, 0x33,
X   0x33, 0x01, 0x80, 0x33, 0x33, 0x01, 0xc0, 0x30, 0x33, 0x39, 0xce, 0x30,
X   0xf3, 0x6c, 0xdb, 0x31, 0x33, 0x6c, 0xdb, 0x30, 0x33, 0x38, 0xce, 0x30,
X   0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x3f};
END_OF_FILE
if test 584 -ne `wc -c <'explode2.bit'`; then
    echo shar: \"'explode2.bit'\" unpacked with wrong size!
fi
# end of 'explode2.bit'
fi
if test -f 'spacer1.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'spacer1.bit'\"
else
echo shar: Extracting \"'spacer1.bit'\" \(181 characters\)
sed "s/^X//" >'spacer1.bit' <<'END_OF_FILE'
X#define spacer_width 16
X#define spacer_height 8
Xstatic char spacer_bits[] = {
X   0xc0, 0x03, 0xf0, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xb6, 0x6d, 0xff, 0xff,
X   0x1c, 0x38, 0x08, 0x10};
END_OF_FILE
if test 181 -ne `wc -c <'spacer1.bit'`; then
    echo shar: \"'spacer1.bit'\" unpacked with wrong size!
fi
# end of 'spacer1.bit'
fi
if test -f 'spacer2.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'spacer2.bit'\"
else
echo shar: Extracting \"'spacer2.bit'\" \(482 characters\)
sed "s/^X//" >'spacer2.bit' <<'END_OF_FILE'
X#define spacer_width 32
X#define spacer_height 16
Xstatic char spacer_bits[] = {
X   0x00, 0xf0, 0x0f, 0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x00,
X   0x00, 0xff, 0xff, 0x00, 0xc0, 0xff, 0xff, 0x03, 0xc0, 0xff, 0xff, 0x03,
X   0xf0, 0xff, 0xff, 0x0f, 0xf0, 0xff, 0xff, 0x0f, 0x38, 0xcf, 0xf3, 0x1c,
X   0x38, 0xcf, 0xf3, 0x1c, 0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
X   0xf0, 0x03, 0xc0, 0x0f, 0xf0, 0x03, 0xc0, 0x0f, 0xc0, 0x00, 0x00, 0x03,
X   0xc0, 0x00, 0x00, 0x03};
END_OF_FILE
if test 482 -ne `wc -c <'spacer2.bit'`; then
    echo shar: \"'spacer2.bit'\" unpacked with wrong size!
fi
# end of 'spacer2.bit'
fi
if test -f 'sperma1.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'sperma1.bit'\"
else
echo shar: Extracting \"'sperma1.bit'\" \(123 characters\)
sed "s/^X//" >'sperma1.bit' <<'END_OF_FILE'
X#define sperma_width 3
X#define sperma_height 7
Xstatic char sperma_bits[] = {
X   0x02, 0x01, 0x02, 0x04, 0x02, 0x01, 0x02};
END_OF_FILE
if test 123 -ne `wc -c <'sperma1.bit'`; then
    echo shar: \"'sperma1.bit'\" unpacked with wrong size!
fi
# end of 'sperma1.bit'
fi
if test -f 'sperma2.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'sperma2.bit'\"
else
echo shar: Extracting \"'sperma2.bit'\" \(178 characters\)
sed "s/^X//" >'sperma2.bit' <<'END_OF_FILE'
X#define newsperma_width 6
X#define newsperma_height 14
Xstatic char newsperma_bits[] = {
X   0x0c, 0x0c, 0x03, 0x03, 0x0c, 0x0c, 0x30, 0x30, 0x0c, 0x0c, 0x03, 0x03,
X   0x0c, 0x0c};
END_OF_FILE
if test 178 -ne `wc -c <'sperma2.bit'`; then
    echo shar: \"'sperma2.bit'\" unpacked with wrong size!
fi
# end of 'sperma2.bit'
fi
if test -f 'spermb1.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'spermb1.bit'\"
else
echo shar: Extracting \"'spermb1.bit'\" \(123 characters\)
sed "s/^X//" >'spermb1.bit' <<'END_OF_FILE'
X#define spermb_width 3
X#define spermb_height 7
Xstatic char spermb_bits[] = {
X   0x02, 0x04, 0x02, 0x01, 0x02, 0x04, 0x02};
END_OF_FILE
if test 123 -ne `wc -c <'spermb1.bit'`; then
    echo shar: \"'spermb1.bit'\" unpacked with wrong size!
fi
# end of 'spermb1.bit'
fi
if test -f 'spermb2.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'spermb2.bit'\"
else
echo shar: Extracting \"'spermb2.bit'\" \(178 characters\)
sed "s/^X//" >'spermb2.bit' <<'END_OF_FILE'
X#define newspermb_width 6
X#define newspermb_height 14
Xstatic char newspermb_bits[] = {
X   0x0c, 0x0c, 0x30, 0x30, 0x0c, 0x0c, 0x03, 0x03, 0x0c, 0x0c, 0x30, 0x30,
X   0x0c, 0x0c};
END_OF_FILE
if test 178 -ne `wc -c <'spermb2.bit'`; then
    echo shar: \"'spermb2.bit'\" unpacked with wrong size!
fi
# end of 'spermb2.bit'
fi
if test -f 'vader1a1.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader1a1.bit'\"
else
echo shar: Extracting \"'vader1a1.bit'\" \(184 characters\)
sed "s/^X//" >'vader1a1.bit' <<'END_OF_FILE'
X#define vader1a_width 10
X#define vader1a_height 8
Xstatic char vader1a_bits[] = {
X   0x30, 0x00, 0x78, 0x00, 0xfc, 0x00, 0xb6, 0x01, 0xfe, 0x01, 0xb4, 0x00,
X   0x02, 0x01, 0x84, 0x00};
END_OF_FILE
if test 184 -ne `wc -c <'vader1a1.bit'`; then
    echo shar: \"'vader1a1.bit'\" unpacked with wrong size!
fi
# end of 'vader1a1.bit'
fi
if test -f 'vader1a2.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader1a2.bit'\"
else
echo shar: Extracting \"'vader1a2.bit'\" \(392 characters\)
sed "s/^X//" >'vader1a2.bit' <<'END_OF_FILE'
X#define newvader1b_width 20
X#define newvader1b_height 16
Xstatic char newvader1b_bits[] = {
X   0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xc0, 0x3f, 0x00, 0xc0, 0x3f, 0x00,
X   0xf0, 0xff, 0x00, 0xf0, 0xff, 0x00, 0x3c, 0xcf, 0x03, 0x3c, 0xcf, 0x03,
X   0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03, 0x30, 0xcf, 0x00, 0x30, 0xcf, 0x00,
X   0x0c, 0x00, 0x03, 0x0c, 0x00, 0x03, 0x30, 0xc0, 0x00, 0x30, 0xc0, 0x00};
END_OF_FILE
if test 392 -ne `wc -c <'vader1a2.bit'`; then
    echo shar: \"'vader1a2.bit'\" unpacked with wrong size!
fi
# end of 'vader1a2.bit'
fi
if test -f 'vader1b1.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader1b1.bit'\"
else
echo shar: Extracting \"'vader1b1.bit'\" \(184 characters\)
sed "s/^X//" >'vader1b1.bit' <<'END_OF_FILE'
X#define vader1b_width 10
X#define vader1b_height 8
Xstatic char vader1b_bits[] = {
X   0x30, 0x00, 0x78, 0x00, 0xfc, 0x00, 0xb6, 0x01, 0xfe, 0x01, 0xb4, 0x00,
X   0x48, 0x00, 0x84, 0x00};
END_OF_FILE
if test 184 -ne `wc -c <'vader1b1.bit'`; then
    echo shar: \"'vader1b1.bit'\" unpacked with wrong size!
fi
# end of 'vader1b1.bit'
fi
if test -f 'vader1b2.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader1b2.bit'\"
else
echo shar: Extracting \"'vader1b2.bit'\" \(392 characters\)
sed "s/^X//" >'vader1b2.bit' <<'END_OF_FILE'
X#define newvader1b_width 20
X#define newvader1b_height 16
Xstatic char newvader1b_bits[] = {
X   0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xc0, 0x3f, 0x00, 0xc0, 0x3f, 0x00,
X   0xf0, 0xff, 0x00, 0xf0, 0xff, 0x00, 0x3c, 0xcf, 0x03, 0x3c, 0xcf, 0x03,
X   0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03, 0x30, 0xcf, 0x00, 0x30, 0xcf, 0x00,
X   0xc0, 0x30, 0x00, 0xc0, 0x30, 0x00, 0x30, 0xc0, 0x00, 0x30, 0xc0, 0x00};
END_OF_FILE
if test 392 -ne `wc -c <'vader1b2.bit'`; then
    echo shar: \"'vader1b2.bit'\" unpacked with wrong size!
fi
# end of 'vader1b2.bit'
fi
if test -f 'vader2a1.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader2a1.bit'\"
else
echo shar: Extracting \"'vader2a1.bit'\" \(184 characters\)
sed "s/^X//" >'vader2a1.bit' <<'END_OF_FILE'
X#define vader2a_width 12
X#define vader2a_height 8
Xstatic char vader2a_bits[] = {
X   0x08, 0x01, 0x90, 0x00, 0xf8, 0x01, 0x6c, 0x03, 0xfe, 0x07, 0xfa, 0x05,
X   0x0a, 0x05, 0x90, 0x00};
END_OF_FILE
if test 184 -ne `wc -c <'vader2a1.bit'`; then
    echo shar: \"'vader2a1.bit'\" unpacked with wrong size!
fi
# end of 'vader2a1.bit'
fi
if test -f 'vader2a2.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader2a2.bit'\"
else
echo shar: Extracting \"'vader2a2.bit'\" \(392 characters\)
sed "s/^X//" >'vader2a2.bit' <<'END_OF_FILE'
X#define newvader2b_width 24
X#define newvader2b_height 16
Xstatic char newvader2b_bits[] = {
X   0xc0, 0x00, 0x03, 0xc0, 0x00, 0x03, 0x00, 0xc3, 0x00, 0x00, 0xc3, 0x00,
X   0xc0, 0xff, 0x03, 0xc0, 0xff, 0x03, 0xf0, 0x3c, 0x0f, 0xf0, 0x3c, 0x0f,
X   0xfc, 0xff, 0x3f, 0xfc, 0xff, 0x3f, 0xcc, 0xff, 0x33, 0xcc, 0xff, 0x33,
X   0xcc, 0x00, 0x33, 0xcc, 0x00, 0x33, 0x00, 0xc3, 0x00, 0x00, 0xc3, 0x00};
END_OF_FILE
if test 392 -ne `wc -c <'vader2a2.bit'`; then
    echo shar: \"'vader2a2.bit'\" unpacked with wrong size!
fi
# end of 'vader2a2.bit'
fi
if test -f 'vader2b1.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader2b1.bit'\"
else
echo shar: Extracting \"'vader2b1.bit'\" \(184 characters\)
sed "s/^X//" >'vader2b1.bit' <<'END_OF_FILE'
X#define vader2b_width 12
X#define vader2b_height 8
Xstatic char vader2b_bits[] = {
X   0x08, 0x01, 0x92, 0x04, 0xfa, 0x05, 0x6e, 0x07, 0xfc, 0x03, 0xf8, 0x01,
X   0x08, 0x01, 0x04, 0x02};
END_OF_FILE
if test 184 -ne `wc -c <'vader2b1.bit'`; then
    echo shar: \"'vader2b1.bit'\" unpacked with wrong size!
fi
# end of 'vader2b1.bit'
fi
if test -f 'vader2b2.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader2b2.bit'\"
else
echo shar: Extracting \"'vader2b2.bit'\" \(392 characters\)
sed "s/^X//" >'vader2b2.bit' <<'END_OF_FILE'
X#define newvader2b_width 24
X#define newvader2b_height 16
Xstatic char newvader2b_bits[] = {
X   0xc0, 0x00, 0x03, 0xc0, 0x00, 0x03, 0x0c, 0xc3, 0x30, 0x0c, 0xc3, 0x30,
X   0xcc, 0xff, 0x33, 0xcc, 0xff, 0x33, 0xfc, 0x3c, 0x3f, 0xfc, 0x3c, 0x3f,
X   0xf0, 0xff, 0x0f, 0xf0, 0xff, 0x0f, 0xc0, 0xff, 0x03, 0xc0, 0xff, 0x03,
X   0xc0, 0x00, 0x03, 0xc0, 0x00, 0x03, 0x30, 0x00, 0x0c, 0x30, 0x00, 0x0c};
END_OF_FILE
if test 392 -ne `wc -c <'vader2b2.bit'`; then
    echo shar: \"'vader2b2.bit'\" unpacked with wrong size!
fi
# end of 'vader2b2.bit'
fi
if test -f 'vader3a1.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader3a1.bit'\"
else
echo shar: Extracting \"'vader3a1.bit'\" \(184 characters\)
sed "s/^X//" >'vader3a1.bit' <<'END_OF_FILE'
X#define vader3a_width 14
X#define vader3a_height 8
Xstatic char vader3a_bits[] = {
X   0xe0, 0x01, 0xfc, 0x0f, 0xfe, 0x1f, 0xce, 0x1c, 0xfe, 0x1f, 0x38, 0x07,
X   0xcc, 0x0c, 0x18, 0x06};
END_OF_FILE
if test 184 -ne `wc -c <'vader3a1.bit'`; then
    echo shar: \"'vader3a1.bit'\" unpacked with wrong size!
fi
# end of 'vader3a1.bit'
fi
if test -f 'vader3a2.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader3a2.bit'\"
else
echo shar: Extracting \"'vader3a2.bit'\" \(485 characters\)
sed "s/^X//" >'vader3a2.bit' <<'END_OF_FILE'
X#define vader3b_width 28
X#define vader3b_height 16
Xstatic char vader3b_bits[] = {
X   0x00, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0xf0, 0xff, 0xff, 0x00,
X   0xf0, 0xff, 0xff, 0x00, 0xfc, 0xff, 0xff, 0x03, 0xfc, 0xff, 0xff, 0x03,
X   0xfc, 0xf0, 0xf0, 0x03, 0xfc, 0xf0, 0xf0, 0x03, 0xfc, 0xff, 0xff, 0x03,
X   0xfc, 0xff, 0xff, 0x03, 0xc0, 0x0f, 0x3f, 0x00, 0xc0, 0x0f, 0x3f, 0x00,
X   0xf0, 0xf0, 0xf0, 0x00, 0xf0, 0xf0, 0xf0, 0x00, 0xc0, 0x03, 0x3c, 0x00,
X   0xc0, 0x03, 0x3c, 0x00};
END_OF_FILE
if test 485 -ne `wc -c <'vader3a2.bit'`; then
    echo shar: \"'vader3a2.bit'\" unpacked with wrong size!
fi
# end of 'vader3a2.bit'
fi
if test -f 'vader3b1.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader3b1.bit'\"
else
echo shar: Extracting \"'vader3b1.bit'\" \(184 characters\)
sed "s/^X//" >'vader3b1.bit' <<'END_OF_FILE'
X#define vader3b_width 14
X#define vader3b_height 8
Xstatic char vader3b_bits[] = {
X   0xe0, 0x01, 0xfc, 0x0f, 0xfe, 0x1f, 0xce, 0x1c, 0xfe, 0x1f, 0x38, 0x07,
X   0xcc, 0x0c, 0x06, 0x18};
END_OF_FILE
if test 184 -ne `wc -c <'vader3b1.bit'`; then
    echo shar: \"'vader3b1.bit'\" unpacked with wrong size!
fi
# end of 'vader3b1.bit'
fi
if test -f 'vader3b2.bit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vader3b2.bit'\"
else
echo shar: Extracting \"'vader3b2.bit'\" \(485 characters\)
sed "s/^X//" >'vader3b2.bit' <<'END_OF_FILE'
X#define vader3b_width 28
X#define vader3b_height 16
Xstatic char vader3b_bits[] = {
X   0x00, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0xf0, 0xff, 0xff, 0x00,
X   0xf0, 0xff, 0xff, 0x00, 0xfc, 0xff, 0xff, 0x03, 0xfc, 0xff, 0xff, 0x03,
X   0xfc, 0xf0, 0xf0, 0x03, 0xfc, 0xf0, 0xf0, 0x03, 0xfc, 0xff, 0xff, 0x03,
X   0xfc, 0xff, 0xff, 0x03, 0xc0, 0x0f, 0x3f, 0x00, 0xc0, 0x0f, 0x3f, 0x00,
X   0xf0, 0xf0, 0xf0, 0x00, 0xf0, 0xf0, 0xf0, 0x00, 0x3c, 0x00, 0xc0, 0x03,
X   0x3c, 0x00, 0xc0, 0x03};
END_OF_FILE
if test 485 -ne `wc -c <'vader3b2.bit'`; then
    echo shar: \"'vader3b2.bit'\" unpacked with wrong size!
fi
# end of 'vader3b2.bit'
fi
echo shar: End of shell archive.
exit 0


dan
----------------------------------------------------
O'Reilly && Associates   [e-mail] / [e-mail]
Opinions expressed reflect those of the author only.